home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_300 / 359_09 / patch4.000 / LIB_BISON.SIM next >
Text File  |  1991-07-21  |  15KB  |  609 lines
  1. /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
  2. #line 3 "bison.simple"
  3.  
  4. /* Skeleton output parser for bison,
  5.    Copyright (C) 1984, 1989, 1990 Bob Corbett and Richard Stallman
  6.  
  7.    This program is free software; you can redistribute it and/or modify
  8.    it under the terms of the GNU General Public License as published by
  9.    the Free Software Foundation; either version 1, or (at your option)
  10.    any later version.
  11.  
  12.    This program is distributed in the hope that it will be useful,
  13.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.    GNU General Public License for more details.
  16.  
  17.    You should have received a copy of the GNU General Public License
  18.    along with this program; if not, write to the Free Software
  19.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20.  
  21.  
  22. #ifndef alloca
  23. #ifdef __GNUC__
  24. #define alloca __builtin_alloca
  25. #else /* Not GNU C.  */
  26. #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__)
  27. #include <alloca.h>
  28. #else /* Not sparc */
  29. #ifdef MSDOS
  30. #include <malloc.h>
  31. #endif /* MSDOS */
  32. #endif /* Not sparc.  */
  33. #endif /* Not GNU C.  */
  34. #endif /* alloca not defined.  */
  35.  
  36. /* This is the parser code that is written into each bison parser
  37.   when the %semantic_parser declaration is not specified in the grammar.
  38.   It was written by Richard Stallman by simplifying the hairy parser
  39.   used when %semantic_parser is specified.  */
  40.  
  41. /* Note: there must be only one dollar sign in this file.
  42.    It is replaced by the list of actions, each action
  43.    as one case of the switch.  */
  44.  
  45. #define yyerrok        (yyerrstatus = 0)
  46. #define yyclearin    (yychar = YYEMPTY)
  47. #define YYEMPTY        -2
  48. #define YYEOF        0
  49. #define YYACCEPT    return(0)
  50. #define YYABORT     return(1)
  51. #define YYERROR        goto yyerrlab1
  52. /* Like YYERROR except do call yyerror.
  53.    This remains here temporarily to ease the
  54.    transition to the new meaning of YYERROR, for GCC.
  55.    Once GCC version 2 has supplanted version 1, this can go.  */
  56. #define YYFAIL        goto yyerrlab
  57. #define YYRECOVERING()  (!!yyerrstatus)
  58. #define YYBACKUP(token, value) \
  59. do                                \
  60.   if (yychar == YYEMPTY && yylen == 1)                \
  61.     { yychar = (token), yylval = (value);            \
  62.       yychar1 = YYTRANSLATE (yychar);                \
  63.       YYPOPSTACK;                        \
  64.       goto yybackup;                        \
  65.     }                                \
  66.   else                                \
  67.     { yyerror ("syntax error: cannot back up"); YYERROR; }    \
  68. while (0)
  69.  
  70. #define YYTERROR    1
  71. #define YYERRCODE    256
  72.  
  73. #ifndef YYPURE
  74. #define YYLEX        yylex()
  75. #endif
  76.  
  77. #ifdef YYPURE
  78. #ifdef YYLSP_NEEDED
  79. #define YYLEX        yylex(&yylval, &yylloc)
  80. #else
  81. #define YYLEX        yylex(&yylval)
  82. #endif
  83. #endif
  84.  
  85. /* If nonreentrant, generate the variables here */
  86.  
  87. #ifndef YYPURE
  88.  
  89. int    yychar;            /*  the lookahead symbol        */
  90. YYSTYPE    yylval;            /*  the semantic value of the        */
  91.                 /*  lookahead symbol            */
  92.  
  93. #ifdef YYLSP_NEEDED
  94. YYLTYPE yylloc;            /*  location data for the lookahead    */
  95.                 /*  symbol                */
  96. #endif
  97.  
  98. int yynerrs;            /*  number of parse errors so far       */
  99. #endif  /* not YYPURE */
  100.  
  101. #if YYDEBUG != 0
  102. int yydebug;            /*  nonzero means print parse trace    */
  103. /* Since this is uninitialized, it does not stop multiple parsers
  104.    from coexisting.  */
  105. #endif
  106.  
  107. /*  YYINITDEPTH indicates the initial size of the parser's stacks    */
  108.  
  109. #ifndef    YYINITDEPTH
  110. #define YYINITDEPTH 200
  111. #endif
  112.  
  113. /*  YYMAXDEPTH is the maximum size the stacks can grow to
  114.     (effective only if the built-in stack extension method is used).  */
  115.  
  116. #if YYMAXDEPTH == 0
  117. #undef YYMAXDEPTH
  118. #endif
  119.  
  120. #ifndef YYMAXDEPTH
  121. #define YYMAXDEPTH 10000
  122. #endif
  123.  
  124. #ifndef __cplusplus
  125.  
  126. /* This is the most reliable way to avoid incompatibilities
  127.    in available built-in functions on various systems.  */
  128. static void
  129. __yy_bcopy (from, to, count)
  130.      char *from;
  131.      char *to;
  132.      int count;
  133. {
  134.   register char *f = from;
  135.   register char *t = to;
  136.   register int i = count;
  137.  
  138.   while (i-- > 0)
  139.     *t++ = *f++;
  140. }
  141.  
  142. #else /* __cplusplus */
  143.  
  144. /* This is the most reliable way to avoid incompatibilities
  145.    in available built-in functions on various systems.  */
  146. static void
  147. __yy_bcopy (char *from, char *to, int count)
  148. {
  149.   register char *f = from;
  150.   register char *t = to;
  151.   register int i = count;
  152.  
  153.   while (i-- > 0)
  154.     *t++ = *f++;
  155. }
  156.  
  157. #endif
  158.  
  159. #line 160 "bison.simple"
  160. int
  161. yyparse()
  162. {
  163.   register int yystate;
  164.   register int yyn;
  165.   register short *yyssp;
  166.   register YYSTYPE *yyvsp;
  167.   int yyerrstatus;    /*  number of tokens to shift before error messages enabled */
  168.   int yychar1;        /*  lookahead token as an internal (translated) token number */
  169.  
  170.   short    yyssa[YYINITDEPTH];    /*  the state stack            */
  171.   YYSTYPE yyvsa[YYINITDEPTH];    /*  the semantic value stack        */
  172.  
  173.   short *yyss = yyssa;        /*  refer to the stacks thru separate pointers */
  174.   YYSTYPE *yyvs = yyvsa;    /*  to allow yyoverflow to reallocate them elsewhere */
  175.  
  176. #ifdef YYLSP_NEEDED
  177.   YYLTYPE yylsa[YYINITDEPTH];    /*  the location stack            */
  178.   YYLTYPE *yyls = yylsa;
  179.   YYLTYPE *yylsp;
  180.  
  181. #define YYPOPSTACK   (yyvsp--, yysp--, yylsp--)
  182. #else
  183. #define YYPOPSTACK   (yyvsp--, yysp--)
  184. #endif
  185.  
  186.   int yystacksize = YYINITDEPTH;
  187.  
  188. #ifdef YYPURE
  189.   int yychar;
  190.   YYSTYPE yylval;
  191.   int yynerrs;
  192. #ifdef YYLSP_NEEDED
  193.   YYLTYPE yylloc;
  194. #endif
  195. #endif
  196.  
  197.   YYSTYPE yyval;        /*  the variable used to return        */
  198.                 /*  semantic values from the action    */
  199.                 /*  routines                */
  200.  
  201.   int yylen;
  202.  
  203. #if YYDEBUG != 0
  204.   if (yydebug)
  205.     fprintf(stderr, "Starting parse\n");
  206. #endif
  207.  
  208.   yystate = 0;
  209.   yyerrstatus = 0;
  210.   yynerrs = 0;
  211.   yychar = YYEMPTY;        /* Cause a token to be read.  */
  212.  
  213.   /* Initialize stack pointers.
  214.      Waste one element of value and location stack
  215.      so that they stay on the same level as the state stack.  */
  216.  
  217.   yyssp = yyss - 1;
  218.   yyvsp = yyvs;
  219. #ifdef YYLSP_NEEDED
  220.   yylsp = yyls;
  221. #endif
  222.  
  223. /* Push a new state, which is found in  yystate  .  */
  224. /* In all cases, when you get here, the value and location stacks
  225.    have just been pushed. so pushing a state here evens the stacks.  */
  226. yynewstate:
  227.  
  228.   *++yyssp = yystate;
  229.  
  230.   if (yyssp >= yyss + yystacksize - 1)
  231.     {
  232.       /* Give user a chance to reallocate the stack */
  233.       /* Use copies of these so that the &'s don't force the real ones into memory. */
  234.       YYSTYPE *yyvs1 = yyvs;
  235.       short *yyss1 = yyss;
  236. #ifdef YYLSP_NEEDED
  237.       YYLTYPE *yyls1 = yyls;
  238. #endif
  239.  
  240.       /* Get the current used size of the three stacks, in elements.  */
  241.       int size = yyssp - yyss + 1;
  242.  
  243. #ifdef yyoverflow
  244.       /* Each stack pointer address is followed by the size of
  245.      the data in use in that stack, in bytes.  */
  246.       yyoverflow("parser stack overflow",
  247.          &yyss1, size * sizeof (*yyssp),
  248.          &yyvs1, size * sizeof (*yyvsp),
  249. #ifdef YYLSP_NEEDED
  250.          &yyls1, size * sizeof (*yylsp),
  251. #endif
  252.          &yystacksize);
  253.  
  254.       yyss = yyss1; yyvs = yyvs1;
  255. #ifdef YYLSP_NEEDED
  256.       yyls = yyls1;
  257. #endif
  258. #else /* no yyoverflow */
  259.       /* Extend the stack our own way.  */
  260.       if (yystacksize >= YYMAXDEPTH)
  261.     {
  262.       yyerror("parser stack overflow");
  263.       return 2;
  264.     }
  265.       yystacksize *= 2;
  266.       if (yystacksize > YYMAXDEPTH)
  267.     yystacksize = YYMAXDEPTH;
  268.       yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
  269.       __yy_bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
  270.       yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
  271.       __yy_bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
  272. #ifdef YYLSP_NEEDED
  273.       yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
  274.       __yy_bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
  275. #endif
  276. #endif /* no yyoverflow */
  277.  
  278.       yyssp = yyss + size - 1;
  279.       yyvsp = yyvs + size - 1;
  280. #ifdef YYLSP_NEEDED
  281.       yylsp = yyls + size - 1;
  282. #endif
  283.  
  284. #if YYDEBUG != 0
  285.       if (yydebug)
  286.     fprintf(stderr, "Stack size increased to %d\n", yystacksize);
  287. #endif
  288.  
  289.       if (yyssp >= yyss + yystacksize - 1)
  290.     YYABORT;
  291.     }
  292.  
  293. #if YYDEBUG != 0
  294.   if (yydebug)
  295.     fprintf(stderr, "Entering state %d\n", yystate);
  296. #endif
  297.  
  298.  yybackup:
  299.  
  300. /* Do appropriate processing given